#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
PLC数据处理脚本
功能：读取"加热炉实验室plc数据信息.xlsx"文件，处理合并单元格，
      生成包含英文参数名称的新表格
"""

import pandas as pd
import numpy as np
import re
from openpyxl import load_workbook
from pathlib import Path
import sys
import requests
import time
import json
from urllib.parse import quote

def translate_text_via_api(text, from_lang='zh', to_lang='en', api_type='baidu'):
    """
    通过翻译API将文本翻译为英文
    
    Args:
        text (str): 需要翻译的文本
        from_lang (str): 源语言代码（zh=中文）
        to_lang (str): 目标语言代码（en=英文）
        api_type (str): 翻译API类型（'baidu', 'youdao', 'google'）
    
    Returns:
        str: 翻译后的文本，如果失败则返回原文本
    """
    if not text or not text.strip():
        return text
    
    try:
        if api_type == 'baidu':
            return translate_baidu(text, from_lang, to_lang)
        elif api_type == 'youdao':
            return translate_youdao(text, from_lang, to_lang)
        elif api_type == 'google':
            return translate_google(text, from_lang, to_lang)
        else:
            print(f"不支持的翻译API类型: {api_type}")
            return text
    except Exception as e:
        print(f"翻译失败: {e}，返回原文本")
        return text

def translate_baidu(text, from_lang, to_lang):
    """
    使用百度翻译API
    注意：需要在百度翻译开放平台获取APP_ID和SECRET_KEY
    """
    # 这里使用免费的翻译接口（仅供演示）
    # 正式使用需要替换为真实的API密钥
    url = "https://fanyi-api.baidu.com/api/trans/vip/translate"
    
    # 模拟翻译结果（实际使用时需要替换为真实的API调用）
    print(f"模拟百度翻译: {text}")
    # 这里可以添加真实的百度翻译API调用代码
    return text.upper().replace(' ', '_')  # 简单模拟

def translate_youdao(text, from_lang, to_lang):
    """
    使用有道翻译API
    """
    print(f"模拟有道翻译: {text}")
    # 这里可以添加真实的有道翻译API调用代码
    return text.upper().replace(' ', '_')  # 简单模拟

def simplify_and_camelcase(text):
    """
    简化并转换为驼峰命名格式 - 更激进的简化
    """
    if not text:
        return text
        
    # 移除标点符号，保留字母数字和空格
    cleaned = re.sub(r'[^A-Za-z0-9\s]', ' ', text)
    
    # 分割单词
    words = cleaned.split()
    
    # 简化单词（移除更多冗余词汇）
    simplified_words = []
    skip_words = {
        'the', 'of', 'and', 'or', 'in', 'on', 'at', 'to', 'for', 'with', 'by',
        'a', 'an', 'is', 'are', 'was', 'were', 'be', 'been', 'being',
        'have', 'has', 'had', 'do', 'does', 'did', 'will', 'would', 'could',
        'rich', 'bench', 'experiment', 'combustion'  # 移除常见的长单词
    }
    
    for word in words:
        word = word.lower().strip()
        if word and word not in skip_words and len(word) > 1:
            # 简化长单词
            if len(word) > 6:  # 降低阈值，更激进的简化
                word = simplify_word(word)
            
            # 过滤空字符串
            if word:
                simplified_words.append(word)
    
    # 如果简化后没有单词，使用更简单的处理
    if not simplified_words:
        # 只保留前3个有意义的单词
        simplified_words = [w.lower() for w in words if w and len(w) > 2][:3]
    
    # 限制总单词数，避免名称过长
    simplified_words = simplified_words[:3]
    
    # 转换为驼峰命名
    if simplified_words:
        result = simplified_words[0].lower()
        for word in simplified_words[1:]:
            result += word.capitalize()
        return result
    
    return text.lower()

def simplify_word(word):
    """
    简化长单词 - 更激进的缩写策略
    """
    word_mapping = {
        'temperature': 'temp',
        'pressure': 'pres',
        'equipment': 'equip',
        'experiment': 'exp',
        'combustion': 'comb',
        'circulation': 'circ',
        'recirculation': 'recirc',
        'actual': 'act',
        'setting': 'set',
        'beginning': 'begin',
        'starting': 'start',
        'section': 'sect',
        'furnace': 'furn',
        'instrument': 'inst',
        'performance': 'perf',
        'exchange': 'exch',
        'before': 'pre',
        'after': 'post',
        'oxygen': 'oxy',
        'rich': '',  # 移除
        'bench': '',  # 移除
        'value': 'val',
        'probe': 'prob',
        'main': 'm',
        'pipe': 'p'
    }
    return word_mapping.get(word.lower(), word)

def translate_google(text, from_lang, to_lang):
    """
    使用本地翻译API服务（基于Hugging Face模型）
    """
    try:
        # 清理输入文本
        text = text.strip()
        if not text:
            return text
            
        # 首先尝试本地API服务
        try:
            local_api_url = "http://localhost:8000/translate"
            payload = {
                "text": text,
                "from_lang": from_lang,
                "to_lang": to_lang
            }
            
            response = requests.post(local_api_url, json=payload, timeout=10)
            if response.status_code == 200:
                result = response.json()
                return result.get('simplified_name', text)
            else:
                print(f"本地API调用失败: {response.status_code}")
        except requests.exceptions.RequestException as e:
            print(f"本地API不可用: {e}")
        
        # 如果本地API不可用，尝试Google翻译
        url = f"https://translate.googleapis.com/translate_a/single?client=gtx&sl={from_lang}&tl={to_lang}&dt=t&q={quote(text)}"
        
        headers = {
            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
        }
        
        response = requests.get(url, headers=headers, timeout=10)
        if response.status_code == 200:
            result = json.loads(response.text)
            if result and len(result) > 0 and len(result[0]) > 0:
                translated = result[0][0][0]
                return translated
        
        print(f"Google翻译请求失败: {response.status_code}")
        return convert_to_english_format(text)
        
    except Exception as e:
        print(f"Google翻译错误: {e}")
        return convert_to_english_format(text)

def convert_to_english_format(chinese_text):
    """
    将中文转换为英文驼峰格式（作为翻译失败的备用方案）
    使用更简短的缩写
    """
    # 简化的中文到英文的转换规则 - 使用更短的缩写
    mapping = {
        'MILD炉': 'mild',
        '炉': 'furn',
        '温度': 'temp', 
        '压力': 'pres',
        '流量': 'flow',
        '空气': 'air',
        '燃气': 'gas', 
        '排烟': 'exh',
        '探头': 'prob',
        '实际': 'act',
        '设定': 'set',
        '换热': 'heat',
        '回流': 'recirc',
        '总管': 'main',
        '段': '',  # 移除段字，直接使用数字
        '时间': 'time',
        '升始': 'start',
        '工艺': 'proc',
        '曲线': 'curve',
        '参数': 'param',
        '前': 'pre',
        '后': 'post',
        '结束': 'end',
        '实验室': '',  # 移除
        '实验': '',   # 移除 
        '台': '',      # 移除
        '数据': '',   # 移除
        '信息': ''    # 移除
    }
    
    result = chinese_text
    # 先处理特殊组合
    for zh, en in mapping.items():
        result = result.replace(zh, en)
    
    # 处理数字段（如 1段时间 -> 1time 或 time1）
    result = re.sub(r'(\d+)time', r'time\1', result)
    result = re.sub(r'(\d+)start', r'start\1', result)
    
    # 移除多余的空格和非英文字符
    result = re.sub(r'[^A-Za-z0-9]', '', result)
    
    # 限制长度，如果过长则截断
    if len(result) > 20:
        # 保留前15个字符和数字部分
        numbers = re.findall(r'\d+', result)
        main_part = re.sub(r'\d+', '', result)[:15]
        result = main_part + ''.join(numbers)
    
    # 转换为驼峰命名（首字母小写）
    if result:
        return result[0].lower() + result[1:] if len(result) > 1 else result.lower()
    
    return chinese_text[:10].lower()  # 如果都失败，直接取前10个字符

def translate_to_english_name_with_api(device_name, param_name, use_api=True, api_type='google'):
    """
    将设备名称和参数名称翻译为英文组合名称（使用API）
    设备名称使用预定义映射，参数名称使用大模型翻译
    
    Args:
        device_name (str): 设备名称
        param_name (str): 参数名称
        use_api (bool): 是否使用翻译API处理参数名称
        api_type (str): 翻译API类型
    
    Returns:
        str: 英文参数名称（驼峰命名）
    """
    if use_api:
        # 使用混合模式：设备名称用映射表，参数名称用大模型翻译
        return translate_to_english_name_hybrid(device_name, param_name, api_type)
    else:
        # 使用直接映射表方法
        return translate_to_english_name_direct(device_name, param_name)

def translate_to_english_name_hybrid(device_name, param_name, api_type='google'):
    """
    混合翻译模式：设备名称使用预定义映射，参数名称使用大模型翻译
    """
    # 获取设备名称前缀（使用预定义映射表）
    device_mapping = {
        'MILD富氧燃烧实验台架': 'mild',
        'MILD炉': 'mild',
        '多功能辐射管烧嘴开发实验台架': 'multiFunc',
        '水喷淋和水雾冷却实验台架': 'waterCool',
        '工艺曲线设定参数': 'proc'
    }
    
    device_en = ""
    if device_name and device_name.strip():
        device_key = device_name.strip()
        if device_key in device_mapping:
            device_en = device_mapping[device_key]
        else:
            # 如果没有直接映射，使用简化规则
            device_en = convert_to_english_format(device_key)
            if len(device_en) > 8:
                device_en = device_en[:8]
    
    # 对于参数名称，优先检查已知映射，否则使用大模型翻译
    param_en = ""
    if param_name and param_name.strip():
        param_key = param_name.strip()
        
        # 先检查已知映射表
        known_param_mapping = {
            '空气换热前实际温度': 'airPreTemp',
            '空气换热后实际温度': 'airPostTemp',
            '排烟换热前实际温度': 'exhPreTemp',
            '排烟换热后实际温度': 'exhPostTemp',
            '温度探头1实际温度': 'temp1',
            '温度探头2实际温度': 'temp2',
            '温度探头3实际温度': 'temp3',
            '温度探头4实际温度': 'temp4',
            '空气实际压力': 'airPres',
            '空气总管实际压力': 'airMainPres',
            '空气实际流量': 'airFlow',
            '空气总管实际流量': 'airMainFlow',
            '烟气回流实际流量': 'gasRecircFlow',
            '燃气实际压力': 'gasPres',
            '燃气总管实际压力': 'gasMainPres',
            '燃气实际流量': 'gasFlow',
            '曲线输出温度': 'curveOutTemp',
            '时间': 'time',
            '升始温度': 'startTemp'
        }
        
        if param_key in known_param_mapping:
            param_en = known_param_mapping[param_key]
        else:
            # 使用大模型翻译
            print(f"  ✨ 使用大模型翻译: {param_key}")
            translated = translate_text_via_api(param_key, api_type=api_type)
            param_en = simplify_and_camelcase(translated)
            
            # 限制参数名称长度
            if len(param_en) > 12:
                param_en = param_en[:12]
    
    # 组合结果，确保唯一性
    if device_en and param_en:
        combined = device_en + param_en.capitalize()
        if len(combined) > 20:
            combined = combined[:20]
        return combined
    elif device_en:
        return device_en
    elif param_en:
        return 'unknown' + param_en.capitalize()
    else:
        return ""

def translate_to_english_name_direct(device_name, param_name):
    """
    直接使用映射表生成短英文名称，确保唯一性
    始终包含设备名称前缀以避免重复
    """
    # 设备名称映射表
    device_mapping = {
        # 三个主要设备的英文前缀
        'MILD富氧燃烧实验台架': 'mild',
        'MILD炉': 'mild',  # 兼容原有名称
        '多功能辐射管烧嘴开发实验台架': 'multiFunc',
        '水喷淋和水雾冷却实验台架': 'waterCool',
        # 其他设备
        '工艺曲线设定参数': 'proc',
        '1段时间': 'stage1',
        '2段时间': 'stage2',
        '3段时间': 'stage3',
        '4段时间': 'stage4',
        '5段时间': 'stage5',
        '6段时间': 'stage6',
        '7段时间': 'stage7',
        '8段时间': 'stage8',
        '9段时间': 'stage9',
        '10段时间': 'stage10',
        '11段时间': 'stage11',
        '12段时间': 'stage12',
        '13段时间': 'stage13',
        '1段升始温度': 'stage1',
        '2段升始温度': 'stage2',
        '3段升始温度': 'stage3',
        '4段升始温度': 'stage4',
        '5段升始温度': 'stage5',
        '6段升始温度': 'stage6',
        '7段升始温度': 'stage7',
        '8段升始温度': 'stage8',
        '9段升始温度': 'stage9',
        '10段升始温度': 'stage10',
        '11段升始温度': 'stage11',
        '12段升始温度': 'stage12',
        '13段升始温度': 'stage13'
    }
    
    # 参数名称映射表
    param_mapping = {
        '空气换热前实际温度': 'airPreTemp',
        '空气换热后实际温度': 'airPostTemp',
        '排烟换热前实际温度': 'exhPreTemp',
        '排烟换热后实际温度': 'exhPostTemp',
        '温度探头1实际温度': 'temp1',
        '温度探头2实际温度': 'temp2',
        '温度探头3实际温度': 'temp3',
        '温度探头4实际温度': 'temp4',
        '空气实际压力': 'airPres',
        '空气总管实际压力': 'airMainPres',
        '空气实际流量': 'airFlow',
        '空气总管实际流量': 'airMainFlow',
        '烟气回流实际流量': 'gasRecircFlow',
        '燃气实际压力': 'gasPres',
        '燃气总管实际压力': 'gasMainPres',
        '燃气实际流量': 'gasFlow',
        '曲线输出温度': 'curveOutTemp',
        '时间': 'time',
        '升始温度': 'startTemp'
    }
    
    # 获取设备名称缩写
    device_en = ""
    if device_name and device_name.strip():
        device_key = device_name.strip()
        if device_key in device_mapping:
            device_en = device_mapping[device_key]
        else:
            # 如果没有直接映射，使用简化规则
            device_en = convert_to_english_format(device_key)
            if len(device_en) > 8:
                device_en = device_en[:8]  # 截断过长的设备名称
    
    # 获取参数名称缩写
    param_en = ""
    if param_name and param_name.strip():
        param_key = param_name.strip()
        if param_key in param_mapping:
            param_en = param_mapping[param_key]
        else:
            # 如果没有直接映射，使用简化规则
            param_en = convert_to_english_format(param_key)
            if len(param_en) > 12:
                param_en = param_en[:12]  # 截断过长的参数名称
    
    # 组合结果，确保唯一性
    if device_en and param_en:
        # 始终使用 设备名 + 参数名 的组合格式
        combined = device_en + param_en.capitalize()
        # 限制总长度
        if len(combined) > 20:
            combined = combined[:20]
        return combined
    elif device_en:
        # 只有设备名称的情况（如时间段等）
        return device_en
    elif param_en:
        # 只有参数名称的情况，但为了唯一性，加上默认前缀
        return 'unknown' + param_en.capitalize()
    else:
        # 都没有的情况，返回空字符串
        return ""


def translate_to_english_name(device_name, param_name):
    # 设备名称翻译映射
    device_mapping = {
        'MILD炉': 'MILD_FURNACE',
        '工艺曲线设定参数': 'PROCESS_CURVE_PARAMS',
        '1段时间': 'STAGE1_TIME',
        '2段时间': 'STAGE2_TIME', 
        '3段时间': 'STAGE3_TIME',
        '4段时间': 'STAGE4_TIME',
        '5段时间': 'STAGE5_TIME',
        '6段时间': 'STAGE6_TIME',
        '7段时间': 'STAGE7_TIME',
        '8段时间': 'STAGE8_TIME',
        '9段时间': 'STAGE9_TIME',
        '10段时间': 'STAGE10_TIME',
        '11段时间': 'STAGE11_TIME',
        '12段时间': 'STAGE12_TIME',
        '13段时间': 'STAGE13_TIME',
        '1段升始温度': 'STAGE1_START_TEMP',
        '2段升始温度': 'STAGE2_START_TEMP',
        '3段升始温度': 'STAGE3_START_TEMP',
        '4段升始温度': 'STAGE4_START_TEMP',
        '5段升始温度': 'STAGE5_START_TEMP',
        '6段升始温度': 'STAGE6_START_TEMP',
        '7段升始温度': 'STAGE7_START_TEMP',
        '8段升始温度': 'STAGE8_START_TEMP',
        '9段升始温度': 'STAGE9_START_TEMP',
        '10段升始温度': 'STAGE10_START_TEMP',
        '11段升始温度': 'STAGE11_START_TEMP',
        '12段升始温度': 'STAGE12_START_TEMP',
        '13段升始温度': 'STAGE13_START_TEMP'
    }
    
    # 参数名称翻译映射
    param_mapping = {
        '空气换热前实际温度': 'AIR_PREHEAT_ACTUAL_TEMP',
        '空气换热后实际温度': 'AIR_POSTHEAT_ACTUAL_TEMP', 
        '排烟换热前实际温度': 'EXHAUST_PREHEAT_ACTUAL_TEMP',
        '排烟换热后实际温度': 'EXHAUST_POSTHEAT_ACTUAL_TEMP',
        '温度探头1实际温度': 'TEMP_PROBE1_ACTUAL',
        '温度探头2实际温度': 'TEMP_PROBE2_ACTUAL',
        '温度探头3实际温度': 'TEMP_PROBE3_ACTUAL',
        '温度探头4实际温度': 'TEMP_PROBE4_ACTUAL',
        '空气实际压力': 'AIR_ACTUAL_PRESSURE',
        '空气总管实际压力': 'AIR_MAIN_ACTUAL_PRESSURE',
        '空气实际流量': 'AIR_ACTUAL_FLOW',
        '空气总管实际流量': 'AIR_MAIN_ACTUAL_FLOW',
        '烟气回流实际流量': 'FLUE_GAS_RECIRCULATION_ACTUAL_FLOW',
        '燃气实际压力': 'GAS_ACTUAL_PRESSURE',
        '燃气总管实际压力': 'GAS_MAIN_ACTUAL_PRESSURE',
        '燃气实际流量': 'GAS_ACTUAL_FLOW'
    }
    
    # 处理设备名称
    device_en = device_mapping.get(device_name, device_name)
    if device_en == device_name and device_name:
        # 如果没有映射，进行简单的拼音转换
        device_en = device_name.replace('段', 'STAGE').replace('时间', 'TIME').replace('升始温度', 'START_TEMP')
    
    # 处理参数名称  
    param_en = param_mapping.get(param_name, param_name)
    if param_en == param_name and param_name:
        # 如果没有映射，进行简单处理
        param_en = param_name.replace(' ', '_').upper()
    
    # 组合英文名称
    if device_en and param_en:
        return f"{device_en}_{param_en}".replace(' ', '_').upper()
    elif param_en:
        return param_en
    else:
        return ""

def process_merged_cells(file_path):
    """
    处理Excel文件中的合并单元格
    
    Args:
        file_path (str): Excel文件路径
    
    Returns:
        pd.DataFrame: 处理后的数据框
    """
    try:
        # 使用openpyxl读取工作簿以获取合并单元格信息
        workbook = load_workbook(file_path)
        sheet = workbook.active
        
        # 获取合并单元格范围
        merged_ranges = list(sheet.merged_cells.ranges)
        
        # 使用pandas读取Excel文件
        df = pd.read_excel(file_path, header=0)
        
        # 处理合并单元格：用第一个非空值填充合并区域
        for merged_range in merged_ranges:
            min_row, min_col = merged_range.min_row - 2, merged_range.min_col - 1  # 调整索引（pandas从0开始，openpyxl从1开始，且有header）
            max_row, max_col = merged_range.max_row - 2, merged_range.max_col - 1
            
            if min_row >= 0 and min_col >= 0 and max_row < len(df) and max_col < len(df.columns):
                # 找到合并区域中的第一个非空值
                merge_value = None
                for row in range(min_row, max_row + 1):
                    for col in range(min_col, max_col + 1):
                        if pd.notna(df.iloc[row, col]) and str(df.iloc[row, col]).strip():
                            merge_value = df.iloc[row, col]
                            break
                    if merge_value is not None:
                        break
                
                # 用该值填充整个合并区域
                if merge_value is not None:
                    for row in range(min_row, max_row + 1):
                        for col in range(min_col, max_col + 1):
                            df.iloc[row, col] = merge_value
        
        return df
    
    except Exception as e:
        print(f"处理合并单元格时发生错误: {e}")
        # 如果处理失败，尝试简单读取
        return pd.read_excel(file_path, header=0)

def process_plc_data(input_file, output_file):
    """
    处理PLC数据文件
    
    Args:
        input_file (str): 输入文件路径
        output_file (str): 输出文件路径
    """
    try:
        print(f"正在读取文件: {input_file}")
        
        # 检查输入文件是否存在
        if not Path(input_file).exists():
            print(f"错误：输入文件 {input_file} 不存在！")
            return False
            
        # 处理合并单元格并读取数据
        df = process_merged_cells(input_file)
        
        print(f"成功读取数据，共 {len(df)} 行")
        print(f"列名: {list(df.columns)}")
        
        # 创建新的数据框，复制所有原始数据
        new_df = df.copy()
        
        # 添加英文参数名称列
        english_names = []
        name_counter = {}  # 用于跟踪重复名称
        
        print("开始生成英文参数名称...")
        
        for index, row in df.iterrows():
            # 获取设备名称和参数名称
            device_name = ""
            param_name = ""
            address = ""
            
            # 尝试从不同列获取设备名称
            if '设备名称' in df.columns:
                device_name = str(row['设备名称']) if pd.notna(row['设备名称']) else ""
            elif len(df.columns) > 1:  # 假设第二列是设备名称
                device_name = str(row.iloc[1]) if pd.notna(row.iloc[1]) else ""
            
            # 尝试从不同列获取参数名称
            if '名称' in df.columns:
                param_name = str(row['名称']) if pd.notna(row['名称']) else ""
            elif '参数名称' in df.columns:
                param_name = str(row['参数名称']) if pd.notna(row['参数名称']) else ""
            elif len(df.columns) > 2:  # 假设第三列是参数名称
                param_name = str(row.iloc[2]) if pd.notna(row.iloc[2]) else ""
            
            # 检查是否有地址列
            has_address = False
            if '地址' in df.columns:
                address = str(row['地址']) if pd.notna(row['地址']) else ""
                has_address = bool(address.strip())
            elif len(df.columns) > 4:  # 假设第五列是地址
                address = str(row.iloc[4]) if pd.notna(row.iloc[4]) else ""
                has_address = bool(address.strip())
            
            # 只有在有地址的情况下才生成英文名称
            if has_address and (device_name.strip() or param_name.strip()):
                # 使用混合模式：设备名称用映射表，参数名称用大模型翻译
                english_name = translate_to_english_name_with_api(
                    device_name.strip(), 
                    param_name.strip(), 
                    use_api=True,  # 启用大模型翻译
                    api_type='google'
                )
                
                # 处理重复名称，确保唯一性
                original_name = english_name
                if english_name in name_counter:
                    name_counter[english_name] += 1
                    english_name = f"{original_name}{name_counter[english_name]}"
                else:
                    name_counter[english_name] = 0
                
                if index < 10:  # 显示前10个示例
                    print(f"  行{index+1}: {device_name.strip()} + {param_name.strip()} -> {english_name}")
            else:
                english_name = ""
            
            english_names.append(english_name)
        
        # 在数据框的最后添加英文参数名称列
        new_df['参数英文名称'] = english_names
        
        # 保存到新文件
        new_df.to_excel(output_file, index=False, engine='openpyxl')
        print(f"成功生成新文件: {output_file}")
        print(f"新文件包含 {len(new_df)} 行数据，{len(new_df.columns)} 列")
        
        # 显示生成的英文名称统计
        non_empty_names = [name for name in english_names if name.strip()]
        unique_names = set(non_empty_names)
        print(f"\n✅ 生成了 {len(non_empty_names)} 个英文参数名称")
        print(f"✅ 唯一名称数量: {len(unique_names)}")
        print(f"✅ 唯一性检查: {'✓ 通过' if len(non_empty_names) == len(unique_names) else '✗ 有重复'}")
        
        # 显示重复名称情况
        if len(non_empty_names) != len(unique_names):
            from collections import Counter
            duplicates = Counter(non_empty_names)
            print("\n重复名称列表:")
            for name, count in duplicates.items():
                if count > 1:
                    print(f"  {name}: 出现 {count} 次")
        
        # 检查最长名称长度
        max_length = max(len(name) for name in non_empty_names) if non_empty_names else 0
        print(f"✅ 最长名称长度: {max_length} 字符")
        print(f"✅ 长度控制: {'✓ 通过' if max_length <= 20 else '✗ 超出限制'}")
        
        if non_empty_names:
            print("\n英文名称示例:")
            for i, name in enumerate(sorted(unique_names)[:15]):  # 显示前15个排序后的名称
                print(f"  {i+1:2d}. {name}")
            if len(unique_names) > 15:
                print(f"  ... 还有 {len(unique_names) - 15} 个名称")
        
        # 显示前几行数据预览
        print("\n数据预览:")
        print(new_df.head().to_string())
        
        return True
        
    except Exception as e:
        print(f"处理文件时发生错误: {e}")
        import traceback
        traceback.print_exc()
        return False

def main():
    """主函数"""
    # 设置文件路径
    script_dir = Path(__file__).parent
    input_file = script_dir / "加热炉实验室plc数据信息.xlsx"
    output_file = script_dir / "加热炉实验室plc数据信息_处理后.xlsx"
    
    print("=== PLC数据处理脚本 ===")
    print(f"脚本目录: {script_dir}")
    print(f"输入文件: {input_file}")
    print(f"输出文件: {output_file}")
    
    # 处理数据
    success = process_plc_data(str(input_file), str(output_file))
    
    if success:
        print("\n✅ 数据处理完成！")
    else:
        print("\n❌ 数据处理失败！")
        sys.exit(1)

if __name__ == "__main__":
    main()